/*
 * CppTokens.c
 *
 *  Created on: 2012/04/12
 *      Author: guanxiaoying
*/
#include "../coredef.h"
#include "cppdef.h"
/*--------------------------------------------------------------*/
/* トークン管理構造体定義                            						        */
/*--------------------------------------------------------------*/
typedef struct _PPTOKENBLOCK{
	AST 	astStart;		/*開始の添え字*/
	AST     astEnd;
	AST 	astCurr;		/*解析した前処理トークン数  */
}PPTOKENBLOCK;
/* トークンブロック情報 */
static PPTOKENBLOCK stPPTokenBlock;

/******************************************************************
* 関 数 名	 : cppTokenSetPPTokenBlock
* 機    能	 : 追加した前処理トークンをstPPTokenBlockに反映
* 引    数 	 : なし
* 戻 り 値   :　なし
* 詳細内容 :
*******************************************************************/
 static VOID  cppTokenSetPPTokenBlock(VOID)
 {
	stPPTokenBlock.astEnd = stCppTokenAccess.getMax();
	if ( stPPTokenBlock.astStart == 0 )
	{
	    stPPTokenBlock.astStart = stPPTokenBlock.astEnd ;
	    stPPTokenBlock.astCurr = stPPTokenBlock.astEnd ;
	}
 }
 static AST cppTokenNew( U2 tokenKind, AST codescp, PSZ name )
 {
	 AST astTableRow;
	/* テーブルKIND_PPTOKEN　を1行追加する */
	if(!stCppTokenAccess.alloc(1))
	{
		return 0;
	}

	/* 連番計算 */
	astTableRow = stCppTokenAccess.getMax();

	/* テーブルKIND_PPTOKENの追加した行のUSHORT_PPTOKENKIND属性にusTokenKindを設定 */
	stCppTokenAccess.tokenKind.set( astTableRow, tokenKind);

	/* テーブルKIND_PPTOKENの追加した行のUSHORT_RECMACRO属性にOFFを設定 */
	/* defaultはOFFですので、処理なし  */

	/* テーブルKIND_PPTOKENの追加した行のIDX_LOCATION属性に「現在位置情報連番」を設定 */
	stCppTokenAccess.codeScp.set( astTableRow, codescp );
	/* テーブルKIND_PPTOKENの追加した行のSTR_PPTOKENNAME属性にpszTokenの文字列を設定 */
	stCppTokenAccess.name.set( astTableRow, name );
	return astTableRow;
 }
/******************************************************************
* 関 数 名 : cppTokenReadComment
* 機    能 :
* 引    数 : pszStart	[in]文字列の先頭アドレス
* 		  ppEnd		[out]コメント削除後、残った文字列のアドレスを返す
* 戻 り 値 : S4
* 	　　　	  COEXIT_SUCCESS		正常終了
*		  COEXIT_FATAL			致命エラー
* 詳細内容 :
*******************************************************************/
static S4 cppTokenReadComment(PSZ pszStart, PSZ *ppszEnd )
{
	S4 nRet = COEXIT_SUCCESS;					/*該当関数の」戻り値*/
	S4 nReadFileRet = COEXIT_SUCCESS;

//	AST astDataCnt = 0;

//	HFILE hFile;

	*ppszEnd	= pszStart;						/*初期化*/

	if( pszStart[0] == '/' )
	{
		CppLocScopeStep(1);
		pszStart = pszStart + 1;

		while( ( pszStart[0] == '\\')&&( pszStart[1] == '\n' ) )
		{

			pszStart = pszStart + 2;
			FATAL_ON_FATAL(CppLineFeed());
		}

		if( pszStart[0] == '/' )
		{
			CppLocScopeStep(1);
			pszStart = pszStart + 1;

			while(1)
			{
				if( ( pszStart[0] == '\\' ) && ( pszStart[1] == '\n' ) )
				{
					pszStart = pszStart + 2;
					FATAL_ON_FATAL(CppLineFeed());
				}
				/* ASCII CODE > 128 の場合、削除  */
				/* ASCII encodingの場合、問題ないですが、
					UTF-8、UTF-16等のencodingの場合、問題あり、
					コメントの終了文字が認識できないおそれがある  */
				else if( pszStart[0] == '\n' )
				{
					break;
				}
				else
				{
					CppLocScopeStep(1);
					pszStart = pszStart + 1;
				}
			}
		}
		else if(pszStart[0] == '*')
		{
			/*「テンポラリバッファー文字数」に　バッファーKIND_BUFSYMNAMEの文字総数　+　1　を代入する*/
			CppLocScopeStep(1);
			pszStart = pszStart + 1;

			while(1)
			{
				if( ( pszStart[0] == '\\' ) && ( pszStart[1] == '\n' ) )
				{
					pszStart = pszStart + 2;
					FATAL_ON_FATAL(CppLineFeed());
				}
				else if( pszStart[0] == '*' )
				{
					CppLocScopeStep(1);
					pszStart = pszStart + 1;

					while( ( pszStart[0] == '\\' ) && ( pszStart[1] == '\n' ) )
					{
						pszStart = pszStart + 2;
						FATAL_ON_FATAL(CppLineFeed());
					}

					if( pszStart[0] == '/' )
					{
						CppLocScopeStep(1);
						pszStart = pszStart + 1;
						break;
					}
				}
				/* ASCII CODE > 128 の場合、削除  */
				/* ASCII encodingの場合、問題ないですが、
					UTF-8、UTF-16等のencodingの場合、問題あり、
					コメントの終了文字が認識できないおそれがある  */
				else if( pszStart[0] == '\0' )
				{
					/*CppCtlFileReadをコールし、もう一行を読み込む*/
//					astDataCnt = stCppNestFileInfoAccess.getMax();;
//					hFile = stCppNestFileInfoAccess.fileHandle.get( astDataCnt );
					nReadFileRet = CppCtlGetFileBuffer(&pszStart);
					if( nReadFileRet != COEXIT_SUCCESS )
					{
						break;
					}
					/* 行情報更新 */
					FATAL_ON_FATAL(CppLineFeed());

					/*KIND_BUFREADのMIN_ARRAY番目からの文字列を　pszStart　に代入する*/
					*ppszEnd = pszStart;
				}
				else
				{
					CppLocScopeStep(1);
					pszStart = pszStart + 1;
				}
			}

			if( nReadFileRet == COEXIT_FATAL )
			{
				return ( COEXIT_FATAL );
			}
			else if( nReadFileRet == COEXIT_FILEEND )
			{
				AST astCodeScp;
				CppLocGetCodeScope(&astCodeScp);
				CppThrowWarning( CPP_COMMENT_NOTEND, astCodeScp, NULL, NULL );
				*ppszEnd = 0;
				return ( COEXIT_SUCCESS );
			}
		}
	}
	*ppszEnd = pszStart;
	return ( nRet );
}




/* オフセット */
/******************************************************************
* 関 数 名	 : cppTokenAddPPToken
* 機    能	 : TOKENをKIND_PPTOKENに追加
* 引    数 	 : pszToken				トークン名
*          len					トークン名の長さ
*          usTokenKind			トークンの種類
* 戻 り 値   :　COEXIT_SUCCESS		成功終了
*          COEXIT_FATAL			致命エラー
*******************************************************************/
static S4 cppTokenAddPPToken(PSZ pszToken, U4 len, U2 usTokenKind)
{
	AST  iCurCodeScp = 0;    /* 現在位置情報連番 */
	AST astTableRow;   /* KIND_PPTOKEN連番 */
	CHAR cTokenLen;     /* pszToken[len]の文字_tmp */
	S4  iRetGetLoc;    /* cppCtlGetLoc戻り値 */
	/* sTokenKindはxPPTOKEN_HSPACEかxPPTOKEN_VSPACEかxPPTOKEN_NEXTLINEである場合 */
	if(  ( usTokenKind == xPPTOKEN_HSPACE )
	   ||( usTokenKind == xPPTOKEN_VSPACE )
	   ||( usTokenKind == xPPTOKEN_NEXTLINE ))
	{
		iCurCodeScp =0;
	}
	else
	{
		iRetGetLoc = CppLocGetCodeScope( &iCurCodeScp );
		if ( iRetGetLoc == COEXIT_FATAL )
		{
			return ( COEXIT_FATAL );
		}
	}


	if(  ( len      > 0   )
	   &&( pszToken != NULL) )
	{
		/* pszToken[len]の文字をテンポラリ変数に格納 */
		cTokenLen = pszToken[len];
		if ( pszToken[len] != '\0' )
		{
			pszToken[len] = '\0';
		}

		astTableRow = cppTokenNew( usTokenKind,  iCurCodeScp, pszToken );
		if( astTableRow == 0 )
		{
			return COEXIT_FATAL;
		}
		/* テンポラリ変数　を　pszToken[len]　に代入 */
		if ( pszToken[len] != cTokenLen ) {
			pszToken[len] = cTokenLen;
		}
	}else
	{
		astTableRow = cppTokenNew( usTokenKind,  iCurCodeScp, "" );
		if( astTableRow == 0 )
		{
			return COEXIT_FATAL;
		}
	}

	cppTokenSetPPTokenBlock();
	return (COEXIT_SUCCESS);
}



 /******************************************************************
 * 関 数 名	 : cppTokenJudgePPNum
 * 機    能	 : 前処理数の終わるかとうかを判断する
 * 引    数 	 : pszStr
 *        : pszStrOld
 * 戻 り 値   :　TRUE　　終わる
 * 　　　　　　　　　FALSE　終わっていない
 * 詳細内容 :
 *******************************************************************/
 static  BOOL cppTokenJudgeSymbol(PSZ pszStr )
 {
 	BOOL ret;
 	S4  iretIsAlnum;

 	if( ( pszStr[0] == '\\') &&( pszStr[1] == '\n') )
 	{
 		pszStr = pszStr + 2;
 	}
 	iretIsAlnum   = isalnum(pszStr[0]);

 	if( iretIsAlnum != FALSE )
     {
         ret = FALSE;          /* 終わっていない */
     }
     else if ( pszStr[0] == '_')
     {
         ret = FALSE;
     }
 	else
 	{
 		ret = TRUE;
 	}

     return (ret);
 }

/******************************************************************
* 関 数 名	 : cppTokenJudgePPNum
* 機    能	 : 前処理数の終わるかとうかを判断する
* 引    数 	 : pszStr
*        : pszStrOld
* 戻 り 値   :　TRUE　　終わる
* 　　　　　　　　　FALSE　終わっていない
* 詳細内容 :
*******************************************************************/
/*debug,13/1/31,S*/
static  BOOL cppTokenJudgePPNum(PSZ pszStr,PSZ pszStrOld,BOOL isHex )
{
	BOOL ret;

	ret = cppTokenJudgeSymbol(pszStr);

	if( ret == FALSE )
    {
        ret = FALSE;          /* 終わっていない */
    }
    else if ( pszStr[0] == '.')
    {
        ret = FALSE;
    }
    else if(  (  ( pszStr[0] == '+' )
               ||( pszStr[0] == '-' ) )
            &&(  ( pszStrOld[0] == 'e')
               ||( pszStrOld[0] == 'E')
               ||( pszStrOld[0] == 'p')  /* c99 */
               ||( pszStrOld[0] == 'P')) )/* c99 */
    {
    	if(isHex){
    		ret = TRUE;
    	}else{
    		ret = FALSE;
    	}
    }
	else
	{
		ret = TRUE;
	}

    return (ret);
}
/*debug,13/1/31,E*/

/************************************************************************/
/* 関 数 名 : 	CppTokenGetNextToken								  			*/
/* 機 　  能 :	次トークンをに移動												*/
/* 引 き 数 : 	bReadNextLine		次の行を取るか否か設定				　		*/
/* 戻 り 値 :	COEXIT_SUCCESS		成功										*/
/*          COEXIT_ERROR        エラー                                                                       	*/
/* 			COEXIT_FINISH		完了										*/
/************************************************************************/
S4 CppTokenGetNextToken(BOOL bSkipSpace, BOOL bReadNextLine)
{
 	S4 nRetVal = 0;
 	AST astDataCnt = 0;
 	PSZ pszBufferRed = NULL;
 	U2 usPPTokenKind = 0;

 	stPPTokenBlock.astCurr++;
 	/*stPPTokenBlockの中にまだ前処理字句がある場合*/
 	if( stPPTokenBlock.astCurr <= stPPTokenBlock.astEnd )
 	{
 		if( bSkipSpace ){
 			usPPTokenKind = stCppTokenAccess.tokenKind.get( stPPTokenBlock.astCurr );
 			while( usPPTokenKind == xPPTOKEN_VSPACE || usPPTokenKind == xPPTOKEN_HSPACE ){
 				stPPTokenBlock.astCurr++;
 				if( stPPTokenBlock.astCurr <= stPPTokenBlock.astEnd ){
 	 				usPPTokenKind = stCppTokenAccess.tokenKind.get( stPPTokenBlock.astCurr );
 				}else{
 					nRetVal = COEXIT_FINISHED;
 					break;
 				}
 			}
 		}
 		if( nRetVal == COEXIT_SUCCESS ){
 			return nRetVal;
 		}
 	}

 	if( bReadNextLine == TRUE )
 	{
		/*１行を読み込む*/
 		while(1)
 		{
			nRetVal = CppCtlGetFileBuffer( &pszBufferRed );
			if( nRetVal == COEXIT_FILEEND )
			{
				return ( COEXIT_FINISHED );
			}
			else if( nRetVal != COEXIT_SUCCESS )
			{
				return ( nRetVal );
			}

			/*読み込んだ１行に対して、前処理字句分解を行う*/
			nRetVal = CppTokenGetTokens( pszBufferRed, FALSE );
			if( nRetVal != COEXIT_SUCCESS )
			{
				return ( nRetVal );
			}

			/* 行先頭の空白、改行を除く */
			astDataCnt = stCppTokenAccess.getMax();
			while (stPPTokenBlock.astCurr <= astDataCnt) {
				usPPTokenKind = stCppTokenAccess.tokenKind.get(stPPTokenBlock.astCurr);
				if ((usPPTokenKind != xPPTOKEN_HSPACE) && (usPPTokenKind != xPPTOKEN_VSPACE) && (usPPTokenKind != xPPTOKEN_NEXTLINE)) {
					break;
				}else {
					stPPTokenBlock.astCurr ++;
				}
			}
			if (stPPTokenBlock.astCurr <= astDataCnt)
			{
				break;
			}
 		}
		/* TOKENの種類は＃の場合、エラーコードCPP_MACRO_COMMAND_INARGを警告する */
		if (usPPTokenKind == xPPTOKEN_SHARP) {
			/* "マクロ[%s]の実引数の中に前処理指令`%s`が見付かりました。\n" */
			CppThrowWarning( CPP_MACRO_COMMAND_INARG,
					stCppTokenAccess.codeScp.get( CUR_TOKEN_INDEX ), NULL, NULL );
		}
		return (COEXIT_SUCCESS);
 	}

 	return (COEXIT_FINISHED);
 }


/******************************************************************
* 関 数 名	 : CppTokenGetTokens
* 機    能	 :
* 引    数 	 : pszStart        分解する文字列
*        : bHeader         ヘッダ名に対応するかのフラグ
* 戻 り 値   : COEXIT_SUCCESS  正常終了
*        : COEXIT_FATAL    致命エラー
* 詳細内容 :
*******************************************************************/
S4 CppTokenGetTokens(PSZ pszStart, BOOL bHeader)
{
	PSZ    	pszCopy;
	PSZ    	pszEnd;
	PSZ    	pszStartOld;        /* pszStart一つ前 */

    S4   	iIsalpha;           /* pszStart[0]が数字か否か */
    S4   	iIsdigit;           /* pszStart[0]が文字か否か */

	BOOL   	blnumJdgRet;        /* 前処理数の終わるかとうか */
    S4   	intRet;
    BOOL   	blisnumret;

    U2	usPPTokenKind = 0;
    BOOL	bPPCmdFlag = FALSE;
    BOOL	bFirstPPToken = TRUE;
    BOOL	bWarnSharpVSpace = FALSE;
    BOOL    bWarning;

	/* 第一引数pszStart NULL */
	if ( pszStart == NULL )
	{
		return (COEXIT_SUCCESS);
	}

	while(usPPTokenKind != xPPTOKEN_END)
	{
		/* 前処理指令かどうかを判断 */
		if (stPPTokenBlock.astEnd != 0) {
			usPPTokenKind = stCppTokenAccess.tokenKind.get(stPPTokenBlock.astEnd);
		}
		if (bFirstPPToken == TRUE) {
			if (usPPTokenKind == xPPTOKEN_SHARP) {
				bPPCmdFlag = TRUE;
				bWarnSharpVSpace = TRUE;
				bFirstPPToken = FALSE;
			}else if (usPPTokenKind != 0 &&
					  usPPTokenKind != xPPTOKEN_VSPACE &&
					  usPPTokenKind != xPPTOKEN_HSPACE &&
					  usPPTokenKind != xPPTOKEN_NEXTLINE) {
				bFirstPPToken = FALSE;
			}
		}else {
			if (bPPCmdFlag == TRUE) {
				if (usPPTokenKind != xPPTOKEN_VSPACE && usPPTokenKind != xPPTOKEN_HSPACE) {
					bPPCmdFlag = FALSE;
				}
			}
		}
		CppLocScopeStart();
		/* 頭文字判定 */
		/* 多バイト文字の場合、誤る判断が起こりえるため、確実な判断を行う   */
		iIsalpha = IS_MULTI_CHAR( *pszStart  )?0:isalpha(pszStart[0]);      /* pszStart[0]数字か */
        iIsdigit =  IS_MULTI_CHAR( *pszStart  )?0:isdigit(pszStart[0]);      /* pszStart[0]文字かか */

	    if ( pszStart[0] == '\0')
	    {
	        break;
	    }
	    /* pszStart[0]は数字である場合 */
		else if ( iIsdigit != FALSE )
		{
			/*debug,13/1/31,S*/
			BOOL isHexPPNum = FALSE;
			if(strlen(pszStart)>=2){
				if(pszStart[0]=='0' && pszStart[1]=='x'){
					isHexPPNum = TRUE;
				}
			}
			/*debug,13/1/31,E*/
			pszStartOld = pszStart; /* pszStart保存 */

			pszCopy = pszStart;
			pszEnd  = pszStart;
	    	pszStart++;
			pszEnd++;

			CppLocScopeStep(1);

			/* 前処理数の終わりまで */
			while( 1 )
			{

				/* 前処理の終わるかとうかを判断する */
				/*debug,13/1/31,S*/
				blnumJdgRet = cppTokenJudgePPNum( pszStart ,pszStartOld,isHexPPNum );
				/*debug,13/1/31,E*/

				if( blnumJdgRet == FALSE)
				{
					/*  '\'+'\n'の組み合わせ */
					if( ( pszStart[0] == '\\')
					  &&( pszStart[1] == '\n') )
					{
						pszStart +=2;       /* pszStartを2文字分で前に進める */
						FATAL_ON_FATAL(CppLineFeed());    /* 改行時テーブルKIND_CURRENTINFO属性変更 */
					}
					else
					{
						pszStartOld = pszStart; /* pszStart保存 */

						*pszEnd = *pszStart;
						CppLocScopeStep(1);
						pszEnd++;
						pszStart++;
					}
				}
				else
			    {
			    	break;
			    }

			}

			/* 前処理数xPPTOKEN_PPNUMの前処理トークンをテーブルKIND_PPTOKENに追加 */
			FATAL_ON_FATAL(cppTokenAddPPToken(pszCopy,(U4)(pszEnd-pszCopy),xPPTOKEN_PPNUM));

		    /* 追加した前処理トークンをstPPTokenBlockに反映 */
		    

		}
		/*  '\' + '\n' の場合 */
		else if( ( pszStart[0] == '\\')
			   &&( pszStart[1] == '\n') )
	    {
			pszStart +=2;       /* pszStartを2文字分で前に進める */
	        FATAL_ON_FATAL(CppLineFeed());    /* 改行時テーブルKIND_CURRENTINFO属性変更 */

	        continue;
	    }
	    /* '\n' の場合 */
	    else if( pszStart[0] == '\n' )
	    {
	    	/* 改行文字xPPTOKEN_NEXTLINEを前処理トークンして             */
	    	/* 中間前処理字句情報テーブルKIND_PPTOKEN　に1個追加する */
            /*FATAL_ON_FATAL(cppTokenAddPPToken("\n", 1, xPPTOKEN_NEXTLINE));*/

		    /* 追加した前処理トークンをstPPTokenBlockに反映 */
		    

		    pszStart++;         /* pszStartを１文字分で前に進める */
		    FATAL_ON_FATAL(CppLineFeed());    /* 改行時テーブルKIND_CURRENTINFO属性変更 */

	        break;
	    }
	    /* 空白か水平タブ（コメント以外の空白類）の場合 */
	    else if (pszStart[0] == ' ' || pszStart[0] == '\t' )
	    {
	    	do {
	    		if( pszStart[0] == ' ' ){
	    			CppLocScopeStep(1);
	    		}else{
	    			CppLocScopeStep(TAB_SIZE);
	    		}
	    		pszStart++;
	    	}while( pszStart[0] == ' ' || pszStart[0] == '\t' );
	    	FATAL_ON_FATAL(cppTokenAddPPToken(" ", 1, xPPTOKEN_HSPACE));
	    	 /* 追加した前処理トークンをstPPTokenBlockに反映 */
		    
		    continue;
	    }
	    /* 垂直タブか書式送り（コメント以外の空白類）の場合 */
	    /* ASCII  垂直タブ = 11 */
	    else if(  ( pszStart[0] == '\v' )
	            ||( pszStart[0] == '\f' ) )
	    {
	    	do {
	    		pszStart++;
	    		CppLocScopeStep(1);
	    	}while( pszStart[0] == '\v' || pszStart[0] == '\f' );
	    	/* 追加した前処理トークンをstPPTokenBlockに反映 */
	    	FATAL_ON_FATAL(cppTokenAddPPToken(" ", 1, xPPTOKEN_VSPACE));
		    
			if( bWarnSharpVSpace )
			{
				CppThrowWarning( CPP_COMMAND_VSPACE_FOUND,
						stCppTokenAccess.codeScp.get( stCppTokenAccess.getMax() ), NULL, NULL );
		  	}
			continue;
	    }
	    /* 文字定数の場合 */
	    else if (pszStart[0] == '\'' || (pszStart[0] == 'L' && pszStart[1] == '\''))
	    {
	    	pszCopy = pszStart;
	    	pszEnd  = pszStart;
	    	if( pszStart[0] == 'L' )
	    	{
		    	pszStart++;
				pszEnd++;
				CppLocScopeStep(1);
	    	}
	    	pszStart++;
			pszEnd++;
			CppLocScopeStep(1);
			while (pszStart[0] != '\'')
			{
				/*  '\'+'\n'の組み合わせ */
				if( ( pszStart[0] == '\\')
				  &&( pszStart[1] == '\n') )
				{
				    pszStart +=2;       /* pszStartを2文字分で前に進める */
				    FATAL_ON_FATAL(CppLineFeed());    /* 改行時テーブルKIND_CURRENTINFO属性変更 */

				    continue;
				}
				else if ( pszStart[0] == '\\' )
				{
					*pszEnd = *pszStart;
					pszStart++;
					pszEnd++;
					CppLocScopeStep(1);

					if ( ( pszStart[0] == '\0')
					   ||( pszStart[0] == '\n') )
					   {
					       break;
					   }
				}
				*pszEnd = *pszStart;
				pszStart++;
				pszEnd++;
				CppLocScopeStep(1);

				if ( ( pszStart[0] == '\0')
				   ||( pszStart[0] == '\n') )
				{
					break;
				}

			}
			bWarning = FALSE;
			if( pszStart[0] != '\'' )
			{
				bWarning = TRUE;
			}
			else
			{
			    *pszEnd = *pszStart;
			    pszStart++;
			    pszEnd++;
			    CppLocScopeStep(1);
			}
			/* xPPTOKEN_HEADERの前処理トークンを１つ中間前処理字句情報テーブルKIND_PPTOKENに追加する */
			FATAL_ON_FATAL(cppTokenAddPPToken(pszCopy,(U4)(pszEnd-pszCopy), xPPTOKEN_CHAR));
			if( bWarning ){
				CppThrowWarning( CPP_PPTOKEN_CHAR_NOTEND,
						stCppTokenAccess.codeScp.get( stCppTokenAccess.getMax() ),
						stCppTokenAccess.name.get(stCppTokenAccess.getMax() ), NULL );
			}
		    continue;
	    }
	    /* bHeader == TRUE かつ　Qヘッダ名の場合 */
	    else if(  ( bHeader     == TRUE )
	            &&( pszStart[0] == '\"'  ) )
	    {
	    	pszCopy = pszStart;
			pszEnd  = pszStart;
			pszStart++;
			pszEnd++;
			CppLocScopeStep(1);
			while (pszStart[0] != '\"')
			{
				/*  '\'+'\n'の組み合わせ */
				if( ( pszStart[0] == '\\')
				  &&( pszStart[1] == '\n') )
				{
				    pszStart +=2;       /* pszStartを2文字分で前に進める */
				    FATAL_ON_FATAL(CppLineFeed());    /* 改行時テーブルKIND_CURRENTINFO属性変更 */

				    continue;
				}
				*pszEnd = *pszStart;
				pszStart++;
				pszEnd++;
				CppLocScopeStep(1);

				if ( ( pszStart[0] == '\0')
				   ||( pszStart[0] == '\n') )
				{
				   break;
				}
			}
			bWarning = FALSE;
			if( pszStart[0] != '\"' )
			{
				bWarning = TRUE;
			}
			else
			{
			    *pszEnd = *pszStart;
			    pszStart++;
			    pszEnd++;
			    CppLocScopeStep(1);
			}
			/* xPPTOKEN_HEADERの前処理トークンを１つ中間前処理字句情報テーブルKIND_PPTOKENに追加する */
			FATAL_ON_FATAL(cppTokenAddPPToken(pszCopy,(U4)(pszEnd-pszCopy), xPPTOKEN_HEADER));

			if( bWarning ){
				CppThrowWarning( CPP_PPTOKEN_HEADER_NOTEND,
						stCppTokenAccess.codeScp.get( stCppTokenAccess.getMax() ),
						stCppTokenAccess.name.get(stCppTokenAccess.getMax() ), NULL );
			}
		    /* bHeader　をFALSEにする */
		    bHeader = FALSE;

		    continue;
	    }
	    /* 文字列リテラルの場合 */
	    else if(pszStart[0] == '\"' || (pszStart[0] == 'L' && pszStart[1] == '\"'))
	    {
	    	pszCopy = pszStart;
	    	pszEnd  = pszStart;
	    	if( pszStart[0] == 'L' )
	    	{
		    	pszStart++;
				pszEnd++;
				CppLocScopeStep(1);
	    	}
			pszStart++;
			pszEnd++;

			CppLocScopeStep(1);
			while (pszStart[0] != '\"')
			{
				/*  '\'+'\n'の組み合わせ */
				if( ( pszStart[0] == '\\')
				  &&( pszStart[1] == '\n') )
				{
				    pszStart +=2;       /* pszStartを2文字分で前に進める */
				    FATAL_ON_FATAL(CppLineFeed());    /* 改行時テーブルKIND_CURRENTINFO属性変更 */

				    continue;
				}
				if( pszStart[0] == '\\')
				{
					*pszEnd =*pszStart;
					pszStart++;
					pszEnd++;
					CppLocScopeStep(1);
					if(  ( pszStart[0] == '\n' )
					   ||( pszStart[0] == '\0' ) )
					{
						break;
					}
				}
				*pszEnd =*pszStart;
				pszStart++;
				pszEnd++;
				CppLocScopeStep(1);
				if(  ( pszStart[0] == '\n' )
				   ||( pszStart[0] == '\0' ))
				{
					break;
				}

			}
			bWarning = FALSE;
			if( pszStart[0] != '\"' )
			{
				bWarning = TRUE;
			}
			else
			{
			    *pszEnd = *pszStart;
			    pszStart++;
			    pszEnd++;
			    CppLocScopeStep(1);
			}
			/* xPPTOKEN_STRの前処理トークンを１つ中間前処理字句情報テーブルKIND_PPTOKENに追加する */
			FATAL_ON_FATAL(cppTokenAddPPToken(pszCopy, (U4)(pszEnd-pszCopy), xPPTOKEN_STR));

			if( bWarning ){
				CppThrowWarning( CPP_PPTOKEN_STRLITER_NOTEND,
						stCppTokenAccess.codeScp.get( stCppTokenAccess.getMax() ),
						stCppTokenAccess.name.get(stCppTokenAccess.getMax() ), NULL );
			}

		    continue;
	    }
	    /* bHeader　== TRUE　且つ　｢<」で始まるの場合 */
	    else if(  ( bHeader     == TRUE )
	            &&( pszStart[0] == '<'  ) )
	    {
	    	pszCopy = pszStart;
			pszEnd  = pszStart;
			pszStart++;
			pszEnd++;
			CppLocScopeStep(1);
			while (pszStart[0] != '>')
			{
				/*  '\'+'\n'の組み合わせ */
				if( ( pszStart[0] == '\\')
				  &&( pszStart[1] == '\n') )
				{
				    pszStart +=2;       /* pszStartを2文字分で前に進める */
				    FATAL_ON_FATAL(CppLineFeed());    /* 改行時テーブルKIND_CURRENTINFO属性変更 */

				    continue;
				}
				*pszEnd =*pszStart;
				pszStart++;
				pszEnd++;
				CppLocScopeStep(1);
				if(  ( pszStart[0] == '\n' )
				   ||( pszStart[0] == '\0' ) )
				{
					break;
				}
			}
			bWarning = FALSE;
			if( pszStart[0] != '>' )
			{
				bWarning = TRUE;
			}
			else
			{
			    *pszEnd = *pszStart;
			    pszStart++;
			    pszEnd++;
			    CppLocScopeStep(1);
			}
			/* xPPTOKEN_HEADERの前処理トークンを１つ中間前処理字句情報テーブルKIND_PPTOKENに追加する */
			FATAL_ON_FATAL(cppTokenAddPPToken(pszCopy, (U4)(pszEnd-pszCopy), xPPTOKEN_HEADER));

			if( bWarning ){
				CppThrowWarning( CPP_PPTOKEN_HEADER_NOTEND,
						stCppTokenAccess.codeScp.get( stCppTokenAccess.getMax() ),
						stCppTokenAccess.name.get(stCppTokenAccess.getMax() ), NULL );
			}

		    /* bHeader　をFALSEにする */
		    bHeader = FALSE;

		    continue;
	    }
	    /* シンボルの場合 */
	    else if(  (iIsalpha    != FALSE )
	            ||(pszStart[0] == '_'   ))
	    {
	    	pszCopy = pszStart;
	    	pszEnd  = pszStart;
	    	pszStart++;
	    	pszEnd++;
	    	CppLocScopeStep(1);

	    	/* 文字は英数字、「_」の場合 */
			while( 1 )
			{

				/* 前処理の終わるかとうかを判断する */
				blnumJdgRet = cppTokenJudgeSymbol( pszStart );

				if( blnumJdgRet == FALSE)
				{
					/*  '\'+'\n'の組み合わせ */
					if( ( pszStart[0] == '\\')
					  &&( pszStart[1] == '\n') )
					{
						pszStart +=2;       /* pszStartを2文字分で前に進める */
						FATAL_ON_FATAL(CppLineFeed());    /* 改行時テーブルKIND_CURRENTINFO属性変更 */
					}
					else
					{
						*pszEnd = *pszStart;
						CppLocScopeStep(1);
						pszEnd++;
						pszStart++;
					}
				}
				else
			    {
			    	break;
			    }

			}
	    	/* xPPTOKEN_SYMの前処理トークンを１つ中間前処理字句情報テーブルKIND_PPTOKENに追加する */
			FATAL_ON_FATAL(cppTokenAddPPToken(pszCopy, (U4)(pszEnd-pszCopy), xPPTOKEN_SYM));


		    /* 前処理includeの場合のみbHeaderをTRUEにする */
		    if (bPPCmdFlag) {
		    	if ( CppIncIsDirectiveCmd(pszCopy, (U4)(pszEnd-pszCopy))) {
		    		bHeader = TRUE;
		    	}
		    }

		    continue;
	    }

	    else
	    {
            switch (pszStart[0])    /* switch ( 現在の文字　） */
            {
            case '=':
                pszStart++;
                CppLocScopeStep(1);

	    	    while(  ( pszStart[0] == '\\')
				      &&( pszStart[1] == '\n') )
	    	    {

				    pszStart +=2;       /* pszStartを2文字分で前に進める */
				    FATAL_ON_FATAL(CppLineFeed());    /* 改行時テーブルKIND_CURRENTINFO属性変更 */
	    	    }
	    	    if( pszStart[0] == '=')
	    	    {
	    	    	pszStart++;
	    	    	CppLocScopeStep(1);
	    	    	/* 前処理トークンを１つ中間前処理字句情報テーブルKIND_PPTOKENに追加する */
	    	    	FATAL_ON_FATAL(cppTokenAddPPToken("==", 2, xPPTOKEN_EQUEQU));
	    	    	/* 追加した前処理トークンをstPPTokenBlockに反映 */
				    
	    	    }
	    	    else
	    	    {
	    	    	/* 前処理トークンを１つ中間前処理字句情報テーブルKIND_PPTOKENに追加する */
	    	    	FATAL_ON_FATAL(cppTokenAddPPToken("=", 1, xPPTOKEN_EQU));
	    	    	/* 追加した前処理トークンをstPPTokenBlockに反映 */
				    
	    	    }
	    	    break;

	    	case '!':
	    		pszStart++;
                CppLocScopeStep(1);

	    	    while(  ( pszStart[0] == '\\')
				      &&( pszStart[1] == '\n') )
	    	    {

				    pszStart +=2;       /* pszStartを2文字分で前に進める */
				    FATAL_ON_FATAL(CppLineFeed());    /* 改行時テーブルKIND_CURRENTINFO属性変更 */
	    	    }
	    	    if( pszStart[0] == '=')
	    	    {
	    	    	pszStart++;
	    	    	CppLocScopeStep(1);
	    	    	/* 前処理トークンを１つ中間前処理字句情報テーブルKIND_PPTOKENに追加する */
	    	    	FATAL_ON_FATAL(cppTokenAddPPToken( "!=", 2, xPPTOKEN_NOTEQU ));
	    	    	/* 追加した前処理トークンをstPPTokenBlockに反映 */
				    
	    	    }
	    	    else
	    	    {
	    	    	/* 前処理トークンを１つ中間前処理字句情報テーブルKIND_PPTOKENに追加する */
	    	    	FATAL_ON_FATAL(cppTokenAddPPToken( "!", 1, xPPTOKEN_NOT ));
	    	    	/* 追加した前処理トークンをstPPTokenBlockに反映 */
				    
	    	    }
	    	    break;

	    	case '-':
	    		pszStart++;
                CppLocScopeStep(1);

	    	    while(  ( pszStart[0] == '\\')
				      &&( pszStart[1] == '\n') )
	    	    {

				    pszStart +=2;       /* pszStartを2文字分で前に進める */
				    FATAL_ON_FATAL(CppLineFeed());    /* 改行時テーブルKIND_CURRENTINFO属性変更 */
	    	    }
	    	    switch ( pszStart[0] )
	    	    {
	    	    case '>':
	    	        pszStart++;
	    	        CppLocScopeStep(1);
	    	        FATAL_ON_FATAL(cppTokenAddPPToken("->",2, xPPTOKEN_POINTERMEM));
	    	        /* 追加した前処理トークンをstPPTokenBlockに反映する */
	                
	    	        break;

	    	    case '-':
	    	        pszStart++;
	    	        CppLocScopeStep(1);
	    	        FATAL_ON_FATAL(cppTokenAddPPToken("--",2, xPPTOKEN_DEC));
	    	        /* 追加した前処理トークンをstPPTokenBlockに反映する */
	                
	    	        break;

	    	    case '=':
	    	        pszStart++;
	    	        CppLocScopeStep(1);
	    	        FATAL_ON_FATAL(cppTokenAddPPToken("-=",2, xPPTOKEN_SUBEQU));
	    	        /* 追加した前処理トークンをstPPTokenBlockに反映する */
	    	        
	    	        break;

	    	    default :
	    	        FATAL_ON_FATAL(cppTokenAddPPToken("-",1, xPPTOKEN_SUB));
	    	        /* 追加した前処理トークンをstPPTokenBlockに反映する */
	                
	    	        break;
	    	    }
	    	    break;

	    	case '+':
	    	    pszStart++;
                CppLocScopeStep(1);

	    	    while(  ( pszStart[0] == '\\')
				      &&( pszStart[1] == '\n') )
	    	    {

				    pszStart +=2;       /* pszStartを2文字分で前に進める */
				    FATAL_ON_FATAL(CppLineFeed());    /* 改行時テーブルKIND_CURRENTINFO属性変更 */
	    	    }
	    	    switch ( pszStart[0] )
	    	    {
	    	    case '+':
	    	        pszStart++;
	    	        CppLocScopeStep(1);
	    	        FATAL_ON_FATAL(cppTokenAddPPToken("++",2, xPPTOKEN_INC));
	    	        /* 追加した前処理トークンをstPPTokenBlockに反映する */
	    	        
				    break;

				case '=':
				    pszStart++;
	    	        CppLocScopeStep(1);
	    	        FATAL_ON_FATAL(cppTokenAddPPToken("+=",2, xPPTOKEN_ADDEQU));
	    	        /* 追加した前処理トークンをstPPTokenBlockに反映する */
	    	        
				    break;

				default :
				    FATAL_ON_FATAL(cppTokenAddPPToken("+",1, xPPTOKEN_ADD));
	    	        /* 追加した前処理トークンをstPPTokenBlockに反映する */
	    	        
	    	        break;
	    	    }
	    	    break;
	    	case '<':
	    	    pszStart++;
                CppLocScopeStep(1);

	    	    while(  ( pszStart[0] == '\\')
				      &&( pszStart[1] == '\n') )
	    	    {

				    pszStart +=2;       /* pszStartを2文字分で前に進める */
				    FATAL_ON_FATAL(CppLineFeed());    /* 改行時テーブルKIND_CURRENTINFO属性変更 */
	    	    }
	    	    switch ( pszStart[0] )
	    	    {
	    	    case '<':
	    	        pszStart++;
	    	        CppLocScopeStep(1);
	    	        while(  ( pszStart[0] == '\\')
				      	  &&( pszStart[1] == '\n') )
	    	        {

					    pszStart +=2;       /* pszStartを2文字分で前に進める */
					    FATAL_ON_FATAL(CppLineFeed());    /* 改行時テーブルKIND_CURRENTINFO属性変更 */
	    	        }
	    	        if ( pszStart[0] == '=' )
	    	        {
	    	        	pszStart++;
	    	        	CppLocScopeStep(1);
	    	        	FATAL_ON_FATAL(cppTokenAddPPToken("<<=",3, xPPTOKEN_LSHTEQU));
		    	        /* 追加した前処理トークンをstPPTokenBlockに反映する */
		    	        
	    	        }
	    	        else
	    	        {
	    	        	FATAL_ON_FATAL(cppTokenAddPPToken("<<",2, xPPTOKEN_LSHT));
		    	        /* 追加した前処理トークンをstPPTokenBlockに反映する */
		    	        
	    	        }
	    	        break;
	    	    case '=':
	    	        pszStart++;
	    	        CppLocScopeStep(1);
	    	        FATAL_ON_FATAL(cppTokenAddPPToken("<=",2, xPPTOKEN_LESSEQU));
		    	    /* 追加した前処理トークンをstPPTokenBlockに反映する */
		    	    
					break;

				default :
				    FATAL_ON_FATAL(cppTokenAddPPToken("<",1, xPPTOKEN_LESS));
		    	    /* 追加した前処理トークンをstPPTokenBlockに反映する */
		    	    
					break;
                }
                break;

            case '>':
                pszStart++;
                CppLocScopeStep(1);

	    	    while(  ( pszStart[0] == '\\')
				      &&( pszStart[1] == '\n') )
	    	    {

				    pszStart +=2;       /* pszStartを2文字分で前に進める */
				    FATAL_ON_FATAL(CppLineFeed());    /* 改行時テーブルKIND_CURRENTINFO属性変更 */
	    	    }
	    	    switch ( pszStart[0] )
	    	    {
	    	    case '>':
	    	        pszStart++;
	    	        CppLocScopeStep(1);
	    	        while(  ( pszStart[0] == '\\')
				      	  &&( pszStart[1] == '\n') )
	    	        {

					    pszStart +=2;       /* pszStartを2文字分で前に進める */
					    FATAL_ON_FATAL(CppLineFeed());    /* 改行時テーブルKIND_CURRENTINFO属性変更 */
	    	        }
	    	        if ( pszStart[0] == '=' )
	    	        {
	    	        	pszStart++;
	    	        	CppLocScopeStep(1);
	    	        	FATAL_ON_FATAL(cppTokenAddPPToken(">>=",3, xPPTOKEN_RSHTEQU));
		    	        /* 追加した前処理トークンをstPPTokenBlockに反映する */
		    	        
	    	        }
	    	        else
	    	        {
	    	        	FATAL_ON_FATAL(cppTokenAddPPToken(">>",2, xPPTOKEN_RSHT));
		    	        /* 追加した前処理トークンをstPPTokenBlockに反映する */
		    	        
	    	        }
	    	        break;
				case '=':
	    	        pszStart++;
	    	        CppLocScopeStep(1);
	    	        FATAL_ON_FATAL(cppTokenAddPPToken(">=",2, xPPTOKEN_MOREEQU));
		    	    /* 追加した前処理トークンをstPPTokenBlockに反映する */
		    	    
					break;
			    default:
			        FATAL_ON_FATAL(cppTokenAddPPToken(">",1, xPPTOKEN_MORE));
		    	    /* 追加した前処理トークンをstPPTokenBlockに反映する */
		    	    
					break;
	    	    }
	    	    break;

	    	case '|':
	    	    pszStart++;
                CppLocScopeStep(1);

	    	    while(  ( pszStart[0] == '\\')
				      &&( pszStart[1] == '\n') )
	    	    {

				    pszStart +=2;       /* pszStartを2文字分で前に進める */
				    FATAL_ON_FATAL(CppLineFeed());    /* 改行時テーブルKIND_CURRENTINFO属性変更 */
	    	    }
	    	    switch ( pszStart[0] )
	    	    {
	    	    case '|':
	    	        pszStart++;
	    	        CppLocScopeStep(1);
	    	        FATAL_ON_FATAL(cppTokenAddPPToken("||",2, xPPTOKEN_OROR));
		    	    /* 追加した前処理トークンをstPPTokenBlockに反映する */
		    	    
					break;
				case '=':
				    pszStart++;
	    	        CppLocScopeStep(1);
	    	        FATAL_ON_FATAL(cppTokenAddPPToken("|=",2, xPPTOKEN_OREQU));
		    	    /* 追加した前処理トークンをstPPTokenBlockに反映する */
		    	    
					break;
				default:
				    FATAL_ON_FATAL(cppTokenAddPPToken("|",1, xPPTOKEN_OR));
		    	    /* 追加した前処理トークンをstPPTokenBlockに反映する */
		    	    
					break;
	    	    }
	    	    break;
	    	case '&':
	    	    pszStart++;
                CppLocScopeStep(1);

	    	    while(  ( pszStart[0] == '\\')
				      &&( pszStart[1] == '\n') )
	    	    {

				    pszStart +=2;       /* pszStartを2文字分で前に進める */
				    FATAL_ON_FATAL(CppLineFeed());    /* 改行時テーブルKIND_CURRENTINFO属性変更 */
	    	    }
	    	    switch ( pszStart[0] )
	    	    {
	    	    case '&':
	    	        pszStart++;
	    	        CppLocScopeStep(1);
	    	        FATAL_ON_FATAL(cppTokenAddPPToken("&&",2, xPPTOKEN_ANDAND));
		    	    /* 追加した前処理トークンをstPPTokenBlockに反映する */
		    	    
					break;

				case '=':
				    pszStart++;
	    	        CppLocScopeStep(1);
	    	        FATAL_ON_FATAL(cppTokenAddPPToken("&=",2, xPPTOKEN_ANDEQU));
		    	    /* 追加した前処理トークンをstPPTokenBlockに反映する */
		    	    
					break;
				default:

				    FATAL_ON_FATAL(cppTokenAddPPToken("&",1, xPPTOKEN_AND));
		    	    /* 追加した前処理トークンをstPPTokenBlockに反映する */
		    	    
					break;
	    	    }
	    	    break;

	    	case '*':
	    	    pszStart++;
                CppLocScopeStep(1);

	    	    while(  ( pszStart[0] == '\\')
				      &&( pszStart[1] == '\n') )
	    	    {

				    pszStart +=2;       /* pszStartを2文字分で前に進める */
				    FATAL_ON_FATAL(CppLineFeed());    /* 改行時テーブルKIND_CURRENTINFO属性変更 */
	    	    }
	    	    if ( pszStart[0] == '=' )
	    	    {
				    pszStart++;
	    	        CppLocScopeStep(1);
	    	        FATAL_ON_FATAL(cppTokenAddPPToken("*=",2, xPPTOKEN_MULEQU));
		    	    /* 追加した前処理トークンをstPPTokenBlockに反映する */
		    	    
	    	    }
	    	    else
	    	    {
				    FATAL_ON_FATAL(cppTokenAddPPToken("*",1, xPPTOKEN_MUL));
		    	    /* 追加した前処理トークンをstPPTokenBlockに反映する */
		    	    
	    	    }
	    	    break;

	        case '/':
	        	pszStartOld = pszStart;
	            pszStart++;
                CppLocScopeStep(1);

	    	    while(  ( pszStart[0] == '\\')
				      &&( pszStart[1] == '\n') )
	    	    {

				    pszStart +=2;       /* pszStartを2文字分で前に進める */
				    FATAL_ON_FATAL(CppLineFeed());    /* 改行時テーブルKIND_CURRENTINFO属性変更 */
	    	    }
	    	    if ( stCoreEnvInfo.ucCppComment == TRUE &&pszStart[0] == '/' )
	    	    {
   	    	        intRet = cppTokenReadComment(pszStartOld, &pszStart);
	    	        if (intRet == COEXIT_FATAL )
	    	        {
	    	            return (COEXIT_FATAL);
	    	        }

	    	        FATAL_ON_FATAL(cppTokenAddPPToken(" ",0, xPPTOKEN_HSPACE));
		    	    /* 追加した前処理トークンをstPPTokenBlockに反映する */
		    	    
		    	    if( pszStart == NULL ){
		    	    	usPPTokenKind = xPPTOKEN_END;
		    	    }
	    	    }
				else if ( pszStart[0] == '*' )
				{
				    intRet = cppTokenReadComment(pszStartOld,&pszStart);
	    	        if (intRet == COEXIT_FATAL )
	    	        {
	    	            return (COEXIT_FATAL);
	    	        }
	    	        FATAL_ON_FATAL(cppTokenAddPPToken(" ",0, xPPTOKEN_HSPACE));
		    	    /* 追加した前処理トークンをstPPTokenBlockに反映する */
		    	    
		    	    if( pszStart == NULL ){
		    	    	usPPTokenKind = xPPTOKEN_END;
		    	    }
				}
			    else if( pszStart[0] == '=' )
			    {
			        pszStart++;
	    	        CppLocScopeStep(1);
	    	        FATAL_ON_FATAL(cppTokenAddPPToken("/=",2, xPPTOKEN_DIVEQU));
		    	    /* 追加した前処理トークンをstPPTokenBlockに反映する */
		    	    
			    }
				else
				{
				    FATAL_ON_FATAL(cppTokenAddPPToken("/",1, xPPTOKEN_DIV));
		    	    /* 追加した前処理トークンをstPPTokenBlockに反映する */
		    	    

	    	    }
	    	    break;

	    	case '%':
	    	    pszStart++;
                CppLocScopeStep(1);

	    	    while(  ( pszStart[0] == '\\')
				      &&( pszStart[1] == '\n') )
	    	    {

				    pszStart +=2;       /* pszStartを2文字分で前に進める */
				    FATAL_ON_FATAL(CppLineFeed());    /* 改行時テーブルKIND_CURRENTINFO属性変更 */
	    	    }
	    	    if ( pszStart[0] == '=')
	    	    {
				    pszStart++;
	    	        CppLocScopeStep(1);
	    	        FATAL_ON_FATAL(cppTokenAddPPToken("%=",2, xPPTOKEN_MODEQU));
		    	    /* 追加した前処理トークンをstPPTokenBlockに反映する */
					
	    	    }
				else
				{
				    FATAL_ON_FATAL(cppTokenAddPPToken("%",1, xPPTOKEN_MOD));
		    	    /* 追加した前処理トークンをstPPTokenBlockに反映する */
					
	    	    }
	    	    break;

	    	case '^':
	    	    pszStart++;
                CppLocScopeStep(1);

	    	    while(  ( pszStart[0] == '\\')
				      &&( pszStart[1] == '\n') )
	    	    {

				    pszStart +=2;       /* pszStartを2文字分で前に進める */
				    FATAL_ON_FATAL(CppLineFeed());    /* 改行時テーブルKIND_CURRENTINFO属性変更 */
	    	    }
	    	    if ( pszStart[0] == '=' )
	    	    {
	    	    	pszStart++;
	    	        CppLocScopeStep(1);
	    	        FATAL_ON_FATAL(cppTokenAddPPToken("^=",2, xPPTOKEN_XOREQU));
		    	    /* 追加した前処理トークンをstPPTokenBlockに反映する */
					
	    	    }
	    	    else
	    	    {
	    	    	FATAL_ON_FATAL(cppTokenAddPPToken("^",1, xPPTOKEN_XOR));
		    	    /* 追加した前処理トークンをstPPTokenBlockに反映する */
					
	    	    }
	    	    break;

	    	case '#':
	    	    pszStart++;
                CppLocScopeStep(1);

	    	    while(  ( pszStart[0] == '\\')
				      &&( pszStart[1] == '\n') )
	    	    {

				    pszStart +=2;       /* pszStartを2文字分で前に進める */
				    FATAL_ON_FATAL(CppLineFeed());    /* 改行時テーブルKIND_CURRENTINFO属性変更 */
	    	    }
	    	    if ( pszStart[0] == '#' )
	    	    {
	    	    	pszStart++;
	    	        CppLocScopeStep(1);
	    	        FATAL_ON_FATAL(cppTokenAddPPToken("##",2, xPPTOKEN_SHARPSHARP));
		    	    /* 追加した前処理トークンをstPPTokenBlockに反映する */
					
	    	    }
	    	    else
	    	    {
	    	    	FATAL_ON_FATAL(cppTokenAddPPToken("#",1, xPPTOKEN_SHARP));
		    	    /* 追加した前処理トークンをstPPTokenBlockに反映する */
					
	    	    }
	    	    break;

            case '.':
                pszCopy = pszStart;
	    	    pszEnd  = pszStart;
                pszStart++;
                pszEnd++;
                CppLocScopeStep(1);

	    	    while(  ( pszStart[0] == '\\')
				      &&( pszStart[1] == '\n') )
	    	    {

				    pszStart +=2;       /* pszStartを2文字分で前に進める */
				    FATAL_ON_FATAL(CppLineFeed());    /* 改行時テーブルKIND_CURRENTINFO属性変更 */
	    	    }
	    	    if ( pszStart[0] == '.' )
	    	    {
	    	        pszStart++;
	                CppLocScopeStep(1);

		    	    while(  ( pszStart[0] == '\\')
					      &&( pszStart[1] == '\n') )
		    	    {

					    pszStart +=2;       /* pszStartを2文字分で前に進める */
					    FATAL_ON_FATAL(CppLineFeed());    /* 改行時テーブルKIND_CURRENTINFO属性変更 */
		    	    }
		    	    if ( pszStart[0] == '.' )
		    	    {
		    	    	pszStart++;
	               	    CppLocScopeStep(1);

	               	    FATAL_ON_FATAL(cppTokenAddPPToken("...",3, xPPTOKEN_ELLIPSIS));
			    	    /* 追加した前処理トークンをstPPTokenBlockに反映する */
						
						break;
		    	    }
		    	    else
		    	    {
		    	    	CppLocScopeStep(-1);
		    	    	FATAL_ON_FATAL(cppTokenAddPPToken(".",1, xPPTOKEN_DOT));
			    	    /* 追加した前処理トークンをstPPTokenBlockに反映する */
						
						CppLocScopeStep(1);
						FATAL_ON_FATAL(cppTokenAddPPToken(".",1, xPPTOKEN_DOT));
			    	    /* 追加した前処理トークンをstPPTokenBlockに反映する */
						
		    	    }
	    	    }
	    	    else if ( isdigit( pszStart[0] ) != FALSE )
	    	    {
	    			/*debug,13/1/31,S*/
	    			BOOL isHexPPNum = FALSE;
	    			if(strlen(pszStart)>=2){
	    				if(pszStart[0]=='0' && pszStart[1]=='x'){
	    					isHexPPNum = TRUE;
	    				}
	    			}
	    			/*debug,13/1/31,E*/
	    	    	/* 前回値保存 */
	    	    	pszStartOld = pszStart;
	    	    	*pszEnd =*pszStart;
	    	    	 pszStart++;
		             pszEnd++;
		             CppLocScopeStep(1);

	    	    	/* 前処理の終わりまで */
					while( 1 )
					{
					    /* 前処理の終わるかとうかを判断する */
						blisnumret = cppTokenJudgePPNum( pszStart ,pszStartOld ,isHexPPNum);

				        if ( blisnumret == FALSE )
					    {
							/*  '\'+'\n'の組み合わせ */
							if( ( pszStart[0] == '\\')
							  &&( pszStart[1] == '\n') )
							{

							    pszStart +=2;       /* pszStartを2文字分で前に進める */
							    FATAL_ON_FATAL(CppLineFeed());    /* 改行時テーブルKIND_CURRENTINFO属性変更 */

							}
							else
							{
								/* 前回値保存 */
		    	    	        pszStartOld = pszStart;

		    	    	        *pszEnd = *pszStart;
								CppLocScopeStep(1);
								pszEnd++;
								pszStart++;

							}
					    }
						else
						{
							break;
						}

					}
					/* 前処理数xPPTOKEN_PPNUMの前処理トークンをテーブルKIND_PPTOKENに追加 */
					FATAL_ON_FATAL(cppTokenAddPPToken(pszCopy,(U4)(pszEnd-pszCopy),xPPTOKEN_PPNUM));
	    	        /* 追加した前処理トークンをstPPTokenBlockに反映する */
	    	        
	    	    }
	    	    else
	    	    {
	    	    	FATAL_ON_FATAL(cppTokenAddPPToken(".",1, xPPTOKEN_DOT));
			    	/* 追加した前処理トークンをstPPTokenBlockに反映する */
				    
	    	    }
	    	    break;

	    	case '[':


				pszStart++;
				CppLocScopeStep(1);
	    	    FATAL_ON_FATAL(cppTokenAddPPToken("[",1, xPPTOKEN_OPENARRAY));
			    /* 追加した前処理トークンをstPPTokenBlockに反映する */
				

				break;

			case ']':


				pszStart++;
				CppLocScopeStep(1);
	    	    FATAL_ON_FATAL(cppTokenAddPPToken("]",1, xPPTOKEN_CLOSEARRAY));
			    /* 追加した前処理トークンをstPPTokenBlockに反映する */
				

				break;

			case '(':


				pszStart++;
				CppLocScopeStep(1);

	    	    FATAL_ON_FATAL(cppTokenAddPPToken("(", 1, xPPTOKEN_OPENPAREN));
			    /* 追加した前処理トークンをstPPTokenBlockに反映する */

				break;

            case ')':


				pszStart++;
				CppLocScopeStep(1);
	    	    FATAL_ON_FATAL(cppTokenAddPPToken(")",1, xPPTOKEN_CLOSEPAREN));
			    /* 追加した前処理トークンをstPPTokenBlockに反映する */


				break;

			case '~':


				pszStart++;
				CppLocScopeStep(1);
	    	    FATAL_ON_FATAL(cppTokenAddPPToken("~",1, xPPTOKEN_NEG));
			    /* 追加した前処理トークンをstPPTokenBlockに反映する */
				

				break;

			case '?':


				pszStart++;
				CppLocScopeStep(1);
	    	    FATAL_ON_FATAL(cppTokenAddPPToken("?",1, xPPTOKEN_QUESTION));
			    /* 追加した前処理トークンをstPPTokenBlockに反映する */
				

				break;

		    case ':':


				pszStart++;
				CppLocScopeStep(1);
	    	    FATAL_ON_FATAL(cppTokenAddPPToken(":",1, xPPTOKEN_COLON));
			    /* 追加した前処理トークンをstPPTokenBlockに反映する */
				
				break;

            case ',':


				pszStart++;
				CppLocScopeStep(1);
	    	    FATAL_ON_FATAL(cppTokenAddPPToken(",",1, xPPTOKEN_COMMA));
			    /* 追加した前処理トークンをstPPTokenBlockに反映する */
				
				break;

			case '{':

				pszStart++;
				CppLocScopeStep(1);
	    	    FATAL_ON_FATAL(cppTokenAddPPToken("{",1, xPPTOKEN_OPENBLOCK));
			    /* 追加した前処理トークンをstPPTokenBlockに反映する */
				

				break;

			case '}':
				pszStart++;
				CppLocScopeStep(1);
	    	    FATAL_ON_FATAL(cppTokenAddPPToken("}",1, xPPTOKEN_CLOSEBLOCK));
			    /* 追加した前処理トークンをstPPTokenBlockに反映する */
				


				break;

			case ';':
				pszStart++;
				CppLocScopeStep(1);
	    	    FATAL_ON_FATAL(cppTokenAddPPToken(";",1, xPPTOKEN_SEMICOLON));
			    /* 追加した前処理トークンをstPPTokenBlockに反映する */
				break;

            default :
				{
					CHAR  cTemp;
					AST astCodeScp;
					if( IS_MULTI_CHAR( *pszStart  ) )
					{
						cTemp = *(pszStart + 2 );
						CppLocScopeStep(2);
						*(pszStart + 2 ) = '\0';
						CppLocGetCodeScope(&astCodeScp);
						if( astCodeScp > 0 ){
							CppThrowWarning( CPP_PPTOKEN_INVALID,
									astCodeScp,
									pszStart, NULL );
						}
	    				*(pszStart + 2 ) = cTemp;
	    				pszStart+=2;
	    			}
	    			else
	    			{
						cTemp = *(pszStart + 1 );
						CppLocScopeStep(1);
						*(pszStart + 1 ) = '\0';
						CppLocGetCodeScope(&astCodeScp);
						if( astCodeScp > 0 ){
							CppThrowWarning( CPP_PPTOKEN_INVALID,
								astCodeScp,
								pszStart, NULL );
						}
	    				*(pszStart + 1 ) = cTemp;
	    				pszStart+=1;
	    			}
	    		}
	    		break;
            }
	    }
	}

    return (COEXIT_SUCCESS);
}
AST CppTokenGetLastNamedToken( VOID ){
 	AST astDataCnt = 0;
 	U2 usPPTokenKind = 0;

 	astDataCnt = stPPTokenBlock.astEnd;
	while( astDataCnt > 0 && astDataCnt >= stPPTokenBlock.astStart  ){
		usPPTokenKind = stCppTokenAccess.tokenKind.get( astDataCnt );
		if( usPPTokenKind == xPPTOKEN_HSPACE || usPPTokenKind == xPPTOKEN_VSPACE
			|| usPPTokenKind == xPPTOKEN_NEXTLINE ){
			astDataCnt--;
		}else{
			return astDataCnt;
		}
	}
	return 0;
}
AST  CppTokenNewOne( U2 tokenKind, AST codescp, PSZ name )
{
	 return cppTokenNew( tokenKind,  codescp, name );
}
/************************************************************************/
/* 関 数 名 : CppTokensDelAll												*/
/* 機    能 :	トークンのメモリを削除												*/
/* 引 き 数 : 	なし															*/
/* 戻 り 値 :	COEXIT_SUCCESS			成功									*/
/*			COEXIT_FATAL			致命エラー								*/
/************************************************************************/
S4 CppTokensDelAll( VOID )
{
	/* テーブルKIND_PPTOKENをクリアする */
	FATAL_ON_FALSE(stCppTokenAccess.clear());
	stPPTokenBlock.astStart = 0;
	stPPTokenBlock.astEnd = 0;
	stPPTokenBlock.astCurr = 0;
	return (COEXIT_SUCCESS);
}
S4  CppTokenDeleteTokensBeforeCurr( AST astToken ){
	AST astN = 0;
	if( astToken >= stPPTokenBlock.astCurr ||  astToken <= 0 || astToken < stPPTokenBlock.astStart  ){
		return COEXIT_SUCCESS;
	}
	if( stPPTokenBlock.astCurr > stPPTokenBlock.astEnd  ){
		if( astToken == stPPTokenBlock.astStart ){
			return CppTokensDelAll();
		}
		stPPTokenBlock.astEnd = astToken - 1;
		stPPTokenBlock.astCurr = astToken;
		return COEXIT_SUCCESS;
	}
	astN = stPPTokenBlock.astEnd - stPPTokenBlock.astCurr + 1 ;
	if( astN > 0 ){
		FATAL_ON_FALSE(stCppTokenAccess.copy( stPPTokenBlock.astCurr, astToken,  astN ));
	}
	stPPTokenBlock.astEnd = astToken + astN - 1;
	stPPTokenBlock.astCurr = astToken;
	return COEXIT_SUCCESS;
}
S4  CppTokenMoveEndTokensToPrev( AST astToken, AST astCnt ){
	AST astNum = 0;
	AST astNew = 0;
	if( stPPTokenBlock.astCurr > stPPTokenBlock.astEnd  ){
		stPPTokenBlock.astCurr = stPPTokenBlock.astEnd + 1;
	}
	if( astCnt <= 0 ||  astToken <= 0 || astToken == stPPTokenBlock.astCurr ){
		return COEXIT_SUCCESS;
	}
	if( stPPTokenBlock.astCurr > stPPTokenBlock.astEnd  ){
		stPPTokenBlock.astCurr = stPPTokenBlock.astEnd + 1;
		FATAL_ON_FALSE(stCppTokenAccess.copy( astToken,  stPPTokenBlock.astCurr, astCnt ));
		stPPTokenBlock.astEnd = stPPTokenBlock.astCurr + astCnt - 1;
		return COEXIT_SUCCESS;
	}
	astNew = stCppTokenAccess.getMax() + 1;
	astNum = stPPTokenBlock.astEnd + 1 - stPPTokenBlock.astCurr;
	FATAL_ON_FALSE( stCppTokenAccess.alloc( astNum ) );
	FATAL_ON_FALSE(stCppTokenAccess.copy( stPPTokenBlock.astCurr, astNew, astNum ));

	FATAL_ON_FALSE(stCppTokenAccess.copy( astToken, stPPTokenBlock.astCurr, astCnt ));

	astToken = stPPTokenBlock.astCurr + astCnt;

	FATAL_ON_FALSE(stCppTokenAccess.copy( astNew, astToken, astNum ));

	stPPTokenBlock.astEnd = astToken + astNum - 1;

	return COEXIT_SUCCESS;
}
AST CppTokenGetLastOne( VOID ){
	return stPPTokenBlock.astEnd;
}
VOID CppTokenResetLastOne( AST astToken ){
	if( stPPTokenBlock.astStart <= astToken ){
		stPPTokenBlock.astEnd = astToken;
	}
}
S4 CppTokenResetCurrOne( AST astToken ){
	if( stPPTokenBlock.astStart <= astToken && astToken <= stPPTokenBlock.astEnd  ){
		stPPTokenBlock.astCurr = astToken;
		return COEXIT_SUCCESS;
	}else{
		return COEXIT_FINISHED;
	}
}
AST CppTokenGetFirstOne( VOID ){
	return stPPTokenBlock.astStart;
}
BOOL CppTokenIsFinished( VOID ){
	if( stPPTokenBlock.astCurr > stPPTokenBlock.astEnd ){
		return TRUE;
	}
	return FALSE;
}
AST CppTokenGetCurrOne( VOID ){
	if( stPPTokenBlock.astCurr <= stPPTokenBlock.astEnd ){
		return stPPTokenBlock.astCurr;
	}else{
		return stPPTokenBlock.astEnd;
	}
}
